home *** CD-ROM | disk | FTP | other *** search
/ AOL File Library: 2,801 to 2,900 / aol-file-protocol-4400-2801-to-2900.zip / AOLDLs / C++ Files Library / SK (Sockects) 1.4.1 r2 / SK v1.4.1 r2.sit / SK 1.4.1 r2 / SK / SK Sources / SK_TCP.cc < prev    next >
Text File  |  1994-06-13  |  33KB  |  1,291 lines
  1. /***************************************************************************
  2. * 
  3. * 
  4. * Copyright ⌐ 1992-1994 Matthias Neeracher and the Decision Systems Group
  5. * 
  6. * Permission is granted to anyone to use this software for any purpose on
  7. * any computer system, and to redistribute it freely, subject to the
  8. * following restrictions:
  9. * 
  10. * 1) The authors and the Decision Systems Group are not responsible for 
  11. *    the direct or indirect consequences of use of this software, no matter 
  12. *    how awful, even if they arise from defects in the software itself.
  13. *    This restriction applies to the use of this and any derived source code 
  14. *    and also to the use of all binary produced from this and any derived 
  15. *    source code.
  16. * 2) The origin and copyrights of this software must not be misrepresented, 
  17. *    either by explicit claim or by omission or alteration of copyright or
  18. *    authorship header information in this file or in any derived file.
  19. * 3) Altered or derived versions must be plainly marked as such, and must not
  20. *    be misrepresented as being the original software.
  21. * 
  22. * We encourage users of this software to provide feedback, bug fixes,
  23. * and enhancements to the authors for incorporation into future releases.
  24. *
  25. * ==========================================================================
  26. * 
  27. * FILE: SK_INET.cc
  28. * 
  29. * AUTHOR: Matthias Neeracher and Stephan Deibel
  30. * 
  31. * CREATION DATE: 12Aug92
  32. * 
  33. * VERSION: 13Jun94
  34. * 
  35. * DESCRIPTION: 
  36. *
  37. * TCP stream sockets implementation
  38. * 
  39. * NOTES: 
  40. * 
  41. * 0) This code was derived from Matthias Neerarcher's GUSI 1.1.0 and
  42. *    the socket library written by Charlie Reiman (creiman@ncsa.uiuc.edu)
  43. *    and Tom Milligan (milligan@madhaus.utcs.utoronto.ca); Copyrights
  44. *    are subject to this origin.
  45. *
  46. * MODIFICATIONS: 
  47. * --------------------------------------------------------------------------
  48. * Date     Name      Description of modification
  49. * --------------------------------------------------------------------------
  50. * 
  51. * 08Sep92    MN       A big part should work now                
  52. * 08Jan93    MN       tcp_notify was setting the wrong state to unconnected
  53. * 17Jan93    MN       Be more careful about user interrupts.
  54. * 21Jan93    MN       Simplify and correct code
  55. * 31Jan93    MN       Support for inetd
  56. * 13Jul93    SD       Port to THINK C++ 6.0
  57. * 21Jul93    SD       Subsetted to only TCP/UDP, applied DSG naming 
  58. *                    conventions and commenting guidelines, and
  59. *                    changed name to "SK" for clear distinction from
  60. *                    the GUSI code from which this was derived
  61. * 13Jun94   SD       Updated based on relevant changes to GUSI (through 1.4.1)
  62. * 
  63. */
  64.  
  65.  
  66. #include "SK_INET_P.hh"
  67.  
  68. /* All completion procedures must use "C" calling and not "C++" -- needed */
  69. /* primarily because of bugs with the THINK C++ 6.0 compiler */
  70.  
  71. extern "C" {
  72.  
  73.  
  74. /**************************************************************************/ 
  75. /**************************************************************************/ 
  76. /* Completion procedures */
  77.  
  78. /*************************************************************************** *
  79. * FUNCTION:
  80. *
  81. * tcp_notify
  82. *
  83. * DESCRIPTION:
  84. *
  85. * TCP notify call back
  86. *
  87. * PARAMETERS:
  88. *
  89. * StreamPtr                -- ???
  90. * u_short                -- ???
  91. * Ptr                    -- ???
  92. * u_short                -- ???
  93. * struct ICMPReport        -- ???
  94. *
  95. */
  96.  
  97. pascal void tcp_notify(
  98.     StreamPtr,
  99.     u_short                    eventCode,
  100.     Ptr                        userDataPtr,
  101.     u_short,
  102.     struct ICMPReport *)
  103. {
  104.     CSK_TCPSocket *    sock    =    *(CSK_TCPSocket **) userDataPtr;
  105.  
  106.     switch (eventCode) {
  107.     case TCPClosing:
  108.         sock->fSocketState = SKk_STATE_CLOSING;
  109.         break;
  110.  
  111.     case TCPTerminate:
  112.         sock->fSocketState = SKk_STATE_UNCONNECTED;
  113.         break;
  114.     }
  115. }
  116.  
  117.  
  118. /*************************************************************************** *
  119. * FUNCTION:
  120. *
  121. * tcp_connect_done
  122. *
  123. * DESCRIPTION:
  124. *
  125. * TCP connect-done call back
  126. *
  127. * PARAMETERS:
  128. *
  129. * CSK_AnnotatedPB *        -- ???
  130. *
  131. */
  132.  
  133. void tcp_connect_done(CSK_AnnotatedPB *pb)
  134. {
  135.     CSK_TCPSocket *    sock = (CSK_TCPSocket *) pb->Owner();
  136.     TCPiopb * tcp = pb->TCP();
  137.  
  138.     if (!tcp->ioResult) {
  139.         sock->fMySocketAddress.sin_addr.s_addr         = tcp->csParam.open.localHost;
  140.         sock->fMySocketAddress.sin_port             = tcp->csParam.open.localPort;
  141.         sock->fPeerSocketAddress.sin_addr.s_addr    = tcp->csParam.open.remoteHost;
  142.         sock->fPeerSocketAddress.sin_port             = tcp->csParam.open.remotePort;
  143.         sock->fSocketState                             = SKk_STATE_CONNECTED;
  144.         sock->fLastAsyncErr                         = noErr;
  145.     }
  146.  
  147.     // Check for nasty error that once plagued us (will be removed eventually)
  148.     ASSERT(tcp->ioResult != inProgress);
  149. }
  150.  
  151.  
  152. /*************************************************************************** *
  153. * FUNCTION:
  154. *
  155. * tcp_listen_done
  156. *
  157. * DESCRIPTION:
  158. *
  159. * TCP listen-done call back
  160. *
  161. * PARAMETERS:
  162. *
  163. * CSK_AnnotatedPB *        -- ???
  164. *
  165. */
  166.  
  167. void tcp_listen_done(CSK_AnnotatedPB *pb)
  168. {
  169.     CSK_TCPSocket *    sock    =    (CSK_TCPSocket *) pb->Owner();
  170.     TCPiopb *    tcp    =    pb->TCP();
  171.  
  172.     switch(tcp->ioResult) {
  173.     case noErr:
  174.         sock->fPeerSocketAddress.sin_addr.s_addr    = tcp->csParam.open.remoteHost;
  175.         sock->fPeerSocketAddress.sin_port             = tcp->csParam.open.remotePort;
  176.         sock->fSocketState                     = SKk_STATE_LIS_CON;
  177.         sock->fLastAsyncErr                 = 0;
  178.         break;
  179.  
  180.     case openFailed:
  181.     case invalidStreamPtr:
  182.     case connectionExists:
  183.     case duplicateSocket:
  184.     case commandTimeout:
  185.     default:
  186.         sock->fSocketState                     = SKk_STATE_UNCONNECTED;
  187.         sock->fLastAsyncErr                 = tcp->ioResult;
  188.         break;
  189.     }
  190.  
  191.     // Check for nasty error that once plagued us (will be removed eventually)
  192.     ASSERT(tcp->ioResult != inProgress);
  193. }
  194.  
  195.  
  196. /*************************************************************************** *
  197. * FUNCTION:
  198. *
  199. * tcp_recv_done
  200. *
  201. * DESCRIPTION:
  202. *
  203. * TCP recv-done call back
  204. *
  205. * PARAMETERS:
  206. *
  207. * CSK_AnnotatedPB *        -- ???
  208. *
  209. */
  210.  
  211. void tcp_recv_done(CSK_AnnotatedPB *pb)
  212. {
  213.     CSK_TCPSocket *        sock    =    (CSK_TCPSocket *) pb->Owner();
  214.     TCPiopb *        tcp    =    pb->TCP();
  215.     register    int     readin;
  216.  
  217.     if (!tcp->ioResult) {
  218.         readin = tcp->csParam.receive.rcvBuffLen;
  219.         sock->fBytesReceived   = readin;
  220.     }
  221.  
  222.     // Check for nasty error that once plagued us (will be removed eventually)
  223.     ASSERT(tcp->ioResult != inProgress);
  224. }
  225.  
  226.  
  227. /*************************************************************************** *
  228. * FUNCTION:
  229. *
  230. * tcp_send_done
  231. *
  232. * DESCRIPTION:
  233. *
  234. * TCP send-done call back
  235. *
  236. * PARAMETERS:
  237. *
  238. * CSK_AnnotatedPB *        -- ???
  239. *
  240. */
  241.  
  242. void tcp_send_done(CSK_AnnotatedPB *pb)
  243. {
  244.     CSK_TCPSocket *    sock    =    (CSK_TCPSocket *) pb->Owner();
  245.     TCPiopb *    tcp    =    pb->TCP();
  246.  
  247.     switch (tcp->ioResult) {
  248.     case noErr:
  249.         ((wdsEntry *)(tcp->csParam.send.wdsPtr))->length = 0;    /* mark it free */
  250.         break;
  251.  
  252.     case ipNoFragMemErr:
  253.     case connectionClosing:
  254.     case connectionTerminated:
  255.     case connectionDoesntExist:
  256.         sock->fSocketState     = SKk_STATE_UNCONNECTED;
  257.         sock->fLastAsyncErr = ENOTCONN;
  258.         break;
  259.  
  260.     case ipDontFragErr:
  261.     case invalidStreamPtr:
  262.     case invalidLength:
  263.     case invalidWDS:
  264.     default:
  265.         sock->fSocketState     = SKk_STATE_UNCONNECTED;
  266.         sock->fLastAsyncErr = tcp->ioResult;
  267.         break;
  268.     }
  269.  
  270.     // Check for nasty error that once plagued us (will be removed eventually)
  271.     ASSERT(tcp->ioResult != inProgress);
  272. }
  273.  
  274. }  /* extern "C" */
  275.  
  276.  
  277.  
  278. /**************************************************************************/ 
  279. /**************************************************************************/ 
  280. /* CSK_TCPSocket members */
  281.  
  282.  
  283. /*************************************************************************** *
  284. * FUNCTION:
  285. *
  286. * CSK_TCPSocket::CSK_TCPSocket
  287. *
  288. * DESCRIPTION:
  289. *
  290. * Constructor for this class
  291. *
  292. */
  293.  
  294. CSK_TCPSocket::CSK_TCPSocket()
  295.     :    CSK_INETSocket()
  296. {
  297.     TCPiopb    pb;
  298.  
  299.     fSocketState = SKk_STATE_UNCONNECTED;
  300.     fSelf = new(CSK_TCPSocket *);
  301.     *fSelf = this;
  302.  
  303.     pb.ioCRefNum                     = SKg_INETSockets.Driver();
  304.     pb.csCode                         = TCPCreate;
  305.     pb.csParam.create.rcvBuff         = (char *) NewPtr(SKk_StreamBufferSize);
  306.     pb.csParam.create.rcvBuffLen     = SKk_StreamBufferSize;
  307.     pb.csParam.create.notifyProc     = tcp_notify;
  308.     pb.csParam.create.userDataPtr    = Ptr(fSelf);
  309.  
  310.     switch(PBControlSync(ParmBlkPtr(&pb)))
  311.     {
  312.         case noErr:                     break;
  313.         case invalidLength:             SK_Error(ENOBUFS);         return;
  314.         case invalidBufPtr:             SK_Error(ENOBUFS);         return;
  315.         case insufficientResources:     SK_Error(EMFILE);         return;
  316.         default:                         SK_Error(ENETDOWN);     return;
  317.     }
  318.  
  319.     fPeerSocketAddress.sin_family = AF_INET;
  320.     fPeerSocketAddress.sin_addr.s_addr = 0;
  321.     fPeerSocketAddress.sin_port = 0;
  322.  
  323.     bzero(&fPeerSocketAddress.sin_zero[0], 8);
  324.  
  325.     fLastAsyncErr = 0;
  326.     fStream = pb.tcpStream;
  327. }
  328.  
  329.  
  330. /*************************************************************************** *
  331. * FUNCTION:
  332. *
  333. * CSK_TCPSocket::CSK_TCPSocket
  334. *
  335. * DESCRIPTION:
  336. *
  337. * Constructor for this class
  338. *
  339. * PARAMETERS:
  340. *
  341. * StreamPtr            -- stream to use with this TCP socket
  342. *
  343. */
  344.  
  345. CSK_TCPSocket::CSK_TCPSocket(StreamPtr stream)
  346.     :    CSK_INETSocket(stream)
  347. {
  348.     AppleEvent theEvent, myReply;
  349.     AEDesc theAddress;
  350.     long theType = 'inet';
  351.     ProcPtr    theProc    = (ProcPtr) tcp_notify;
  352.     ProcessSerialNumber    PSN;
  353.  
  354.     fSelf = new(CSK_TCPSocket *);
  355.     *fSelf = this;
  356.     fLastAsyncErr = 0;
  357.  
  358.     GetCurrentProcess(&PSN);
  359.     AECreateDesc(typeApplSignature, (Ptr) &theType, sizeof(theType), &theAddress);
  360.     AECreateAppleEvent('INET', 'TNFY',  &theAddress, kAutoGenerateReturnID, kAnyTransactionID, &theEvent);
  361.     
  362.     AEPutParamPtr(&theEvent, 'STRM', typeLongInteger, (Ptr) &fStream, sizeof(fStream));
  363.     AEPutParamPtr(&theEvent, 'ASR ', typeLongInteger, (Ptr) &theProc, sizeof(ProcPtr));
  364.     AEPutParamPtr(&theEvent, 'USRP', typeLongInteger, (Ptr) &fSelf, sizeof(long));
  365.     AEPutParamPtr(&theEvent, keyProcessSerialNumber, typeProcessSerialNumber, (Ptr) &PSN, sizeof(ProcessSerialNumber));
  366.     
  367.     AESend(&theEvent, &myReply, kAEWaitReply, kAEHighPriority, 120, nil, nil);
  368.  
  369.     AEDisposeDesc(&myReply);
  370.     AEDisposeDesc(&theEvent);
  371.     AEDisposeDesc(&theAddress);
  372.  
  373.     TCPiopb * pb;
  374.  
  375.     pb                = GetPB();
  376.     pb->csCode     = TCPStatus;
  377.  
  378.     PBControlSync(ParmBlkPtr(pb));
  379.     
  380.     fMySocketAddress.sin_addr.s_addr     =     pb->csParam.status.localHost;
  381.     fMySocketAddress.sin_port                =    pb->csParam.status.localPort;
  382.     fPeerSocketAddress.sin_addr.s_addr =     pb->csParam.status.remoteHost;
  383.     fPeerSocketAddress.sin_port            =    pb->csParam.status.remotePort;
  384.     
  385.     // Check for nasty error that once plagued us (will be removed eventually)
  386.     ASSERT(pb->ioResult != inProgress);
  387. }
  388.  
  389.  
  390. /*************************************************************************** *
  391. * FUNCTION:
  392. *
  393. * CSK_TCPSocket::CSK_TCPSocket
  394. *
  395. * DESCRIPTION:
  396. *
  397. * Constructor for this class
  398. *
  399. * PARAMETERS:
  400. *
  401. * CSK_TCPSocket *        -- Existing TCP socket to used as template for initialization
  402. *
  403. */
  404.  
  405. CSK_TCPSocket::CSK_TCPSocket(CSK_TCPSocket * sock)
  406. {
  407.     fStream    = sock->fStream;
  408.     fStatus    = sock->fStatus;
  409.     fNonBlocking= sock->fNonBlocking;
  410.     fReceiveBuf    = sock->fReceiveBuf;
  411.     fBytesReceived = sock->fBytesReceived;
  412.     fMySocketAddress = sock->fMySocketAddress;
  413.     fPeerSocketAddress = sock->fPeerSocketAddress;
  414.     fSocketState = sock->fSocketState;
  415.     fLastAsyncErr = 0;
  416.     
  417.     // The reason for this strange code is that fStream->userData points to
  418.     // sock.fSelf and cannot be changed while the stream is alive
  419.     
  420.     fSelf = sock->fSelf;
  421.     *fSelf = this;
  422.     sock->fSelf    = new(CSK_TCPSocket *);
  423.     *sock->fSelf = sock;
  424. }
  425.  
  426.  
  427. /*************************************************************************** *
  428. * FUNCTION:
  429. *
  430. * CSK_TCPSocket::~CSK_TCPSocket
  431. *
  432. * DESCRIPTION:
  433. *
  434. * Destructor for this class
  435. *
  436. */
  437.  
  438. CSK_TCPSocket::~CSK_TCPSocket()
  439. {
  440.     TCPiopb *    pb;
  441.  
  442.     do {
  443.         pb                = GetPB();
  444.         pb->csCode         = TCPStatus;
  445.  
  446.         PBControlSync(ParmBlkPtr(pb));
  447.  
  448.         // Check for nasty error that once plagued us (will be removed eventually)
  449.         ASSERT(pb->ioResult != inProgress);
  450.  
  451.         SAFESPIN(false, SKk_MISC, 0);
  452.     } while (!errno && pb->csParam.status.amtUnackedData > 0);
  453.  
  454.     pb = GetPB();
  455.     pb->ioCompletion = nil;
  456.     pb->csCode = TCPClose;
  457.     pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
  458.     pb->csParam.close.ulpTimeoutValue = 60 /* seconds */;
  459.     pb->csParam.close.ulpTimeoutAction     = 1 /* 1:abort 0:report */;
  460.  
  461.     switch (PBControlAsync(ParmBlkPtr(pb)))
  462.     {
  463.         case noErr:
  464.         case connectionClosing:
  465.             break;
  466.         case connectionDoesntExist:
  467.         case connectionTerminated:
  468.             break;
  469.         case invalidStreamPtr:
  470.         default:
  471.             return;
  472.     }
  473.     
  474.     {
  475.         rdsEntry    rdsarray[SKk_TCPMaxWds+1];
  476.         int        passcount;
  477.         const int maxpass =4;
  478.  
  479.         pb                    =    GetPB();
  480.  
  481.         for (passcount=0; passcount<maxpass; passcount++) {
  482.             pb->csCode                                             = TCPNoCopyRcv;
  483.             pb->csParam.receive.commandTimeoutValue    = 1; /* seconds, 0 = blocking */
  484.             pb->csParam.receive.rdsPtr                     = (Ptr)rdsarray;
  485.             pb->csParam.receive.rdsLength                 = SKk_TCPMaxWds;
  486.  
  487.             if (PBControlSync(ParmBlkPtr(pb)))
  488.                 break;
  489.  
  490.             pb->csCode                                             = TCPRcvBfrReturn;
  491.             pb->csParam.receive.rdsPtr                     = (Ptr)rdsarray;
  492.  
  493.             PBControlSync(ParmBlkPtr(pb));
  494.  
  495.             // Check for nasty error that once plagued us (will be removed eventually)
  496.             ASSERT(pb->ioResult != inProgress);
  497.  
  498.             SAFESPIN(false, SKk_MISC, 0);
  499.             
  500.             if (errno)
  501.                 break;
  502.         }
  503.  
  504.  
  505.         if (passcount == maxpass) {        /* remote side isn't being nice */
  506.             /* then try again */
  507.  
  508.             PBControlSync(ParmBlkPtr(pb));
  509.  
  510.             // Check for nasty error that once plagued us (will be removed eventually)
  511.             ASSERT(pb->ioResult != inProgress);
  512.  
  513.             for (passcount=0; passcount<maxpass; passcount++) {
  514.                 pb->csCode                                             = TCPNoCopyRcv;
  515.                 pb->csParam.receive.commandTimeoutValue    = 1; /* seconds, 0 = blocking */
  516.                 pb->csParam.receive.rdsPtr                     = (Ptr)rdsarray;
  517.                 pb->csParam.receive.rdsLength                 = SKk_TCPMaxWds;
  518.  
  519.                 if (PBControlSync(ParmBlkPtr(pb)))
  520.                     break;
  521.  
  522.                 pb->csCode                                             = TCPRcvBfrReturn;
  523.                 pb->csParam.receive.rdsPtr                     = (Ptr)rdsarray;
  524.  
  525.                 PBControlSync(ParmBlkPtr(pb));
  526.  
  527.                 // Check for nasty error that once plagued us (will be removed eventually)
  528.                 ASSERT(pb->ioResult != inProgress);
  529.  
  530.                 SAFESPIN(false, SKk_MISC, 0);
  531.                 
  532.                 if (errno)
  533.                     break;
  534.             }
  535.  
  536.         }
  537.     }
  538.  
  539.     /* destroy the stream */
  540.     pb->csCode     = TCPRelease;
  541.  
  542.     if (PBControlSync(ParmBlkPtr(pb)))
  543.         return;
  544.  
  545.     // Check for nasty error that once plagued us (will be removed eventually)
  546.     ASSERT(pb->ioResult != inProgress);
  547.     
  548.     DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
  549.     
  550.     delete fSelf;
  551. }
  552.  
  553.  
  554. /*************************************************************************** *
  555. * FUNCTION:
  556. *
  557. * CSK_TCPSocket::GetPB
  558. *
  559. * DESCRIPTION:
  560. *
  561. * Get a TCP io parameter block for use with this TCP socket.  The
  562. * parameter block is obtained from the SKg_INETSockets domain object
  563. * and is set up for use specifically with this socket.
  564. *
  565. * RETURNS:
  566. *
  567. * TCPiopb *            -- The TCP io parameter block
  568. *
  569. */
  570.  
  571. TCPiopb * CSK_TCPSocket::GetPB()
  572. {
  573.     CSK_AnnotatedPB *    pb        =    SKg_INETSockets.GetPB();
  574.     pb->TCP()->ioCRefNum =    SKg_INETSockets.Driver();
  575.     pb->TCP()->tcpStream    =    fStream;
  576.  
  577.     pb->SetOwner(this);
  578.  
  579.     return pb->TCP();
  580. }
  581.  
  582.  
  583. /*************************************************************************** *
  584. * FUNCTION:
  585. *
  586. * CSK_TCPSocket::Available
  587. *
  588. * DESCRIPTION:
  589. *
  590. * Return number of bytes of unread data available on this socket
  591. *
  592. * RETURNS:
  593. *
  594. * u_long        -- The number of unread bytes available
  595. *
  596. */
  597.  
  598. u_long CSK_TCPSocket::Available()
  599. {
  600.     TCPiopb * pb;
  601.  
  602.     pb                = GetPB();
  603.     pb->csCode     = TCPStatus;
  604.  
  605.     PBControlSync(ParmBlkPtr(pb));
  606.  
  607.     // Check for nasty error that once plagued us (will be removed eventually)
  608.     ASSERT(pb->ioResult != inProgress);
  609.     
  610.     return pb->csParam.status.amtUnreadData;
  611. }
  612.  
  613.  
  614. /*************************************************************************** *
  615. * FUNCTION:
  616. * 
  617. * CSK_TCPSocket::connect
  618. *
  619. * DESCRIPTION:
  620. *
  621. * Initiate a connection on a MacTCP socket.  This call attempts to make a 
  622. * connection to another socket. The other socket is specified by an internet 
  623. * address and port.
  624. *
  625. * PARAMETERS:
  626. *
  627. * void *         -- The internet address and port
  628. * int            -- The length of the given internet address information
  629. *
  630. * RETURNS:
  631. *
  632. * If the connection or binding succeeds, then 0 is returned.
  633. * Otherwise a -1 is returned, and a more specific error code is stored in
  634. * errno:
  635. *
  636. *    EAFNOSUPPORT      The address family in addr is not AF_INET.
  637. *
  638. *    EHOSTUNREACH      The TCP connection came up half-way and then failed.
  639. *
  640. * NOTES:
  641. *
  642. * TCP sockets may successfully connect() only once;
  643. *
  644. */
  645.  
  646. int CSK_TCPSocket::connect(void * address, int addrlen)
  647. {
  648.     OSErr                    err;
  649.     struct sockaddr_in *    addr = (struct sockaddr_in *) address;
  650.     TCPiopb    *                pb;
  651.  
  652.     ASSERT(addrlen == sizeof(struct sockaddr_in));
  653.  
  654.     if (addr->sin_family != AF_INET)
  655.         return SK_Error(EAFNOSUPPORT);
  656.  
  657.     /* Make sure this socket can connect */
  658.     if (fSocketState == SKk_STATE_CONNECTING)
  659.         return SK_Error(EALREADY);
  660.     if (fSocketState != SKk_STATE_UNCONNECTED)
  661.         return SK_Error(EISCONN);
  662.  
  663.     fSocketState = SKk_STATE_CONNECTING;
  664.  
  665.     pb = GetPB();
  666.     pb->ioCompletion = TCPIOCompletionProc(tcp_connect_done);
  667.     pb->csCode = TCPActiveOpen;
  668.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  669.     pb->csParam.open.ulpTimeoutValue = 60 /* seconds */;
  670.     pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  671.     pb->csParam.open.commandTimeoutValue = 0;
  672.     pb->csParam.open.remoteHost = addr->sin_addr.s_addr;
  673.     pb->csParam.open.remotePort = addr->sin_port;
  674.     pb->csParam.open.localHost = 0;
  675.     pb->csParam.open.localPort = fMySocketAddress.sin_port;
  676.     pb->csParam.open.dontFrag = 0;
  677.     pb->csParam.open.timeToLive = 0;
  678.     pb->csParam.open.security = 0;
  679.     pb->csParam.open.optionCnt = 0;
  680.  
  681.     err = PBControlAsync(ParmBlkPtr(pb));
  682.     if (err != 0)
  683.     {
  684.         fSocketState = SKk_STATE_UNCONNECTED;
  685.         return SK_TCPError(err);
  686.     }
  687.  
  688.     if (fNonBlocking)
  689.         return SK_Error(EINPROGRESS);
  690.  
  691.     /* sync connect - spin till TCPActiveOpen completes */
  692.  
  693.     SAFESPIN(pb->ioResult==inProgress, SKk_MISC, 0);
  694.  
  695.     if (errno || pb->ioResult) {
  696.         fSocketState = SKk_STATE_UNCONNECTED;
  697.         
  698.         if (errno)
  699.             return -1;
  700.         else
  701.             return SK_TCPError(pb->ioResult);
  702.     } else
  703.         return 0;
  704. }
  705.  
  706.  
  707. /*************************************************************************** *
  708. * FUNCTION:
  709. *
  710. * CSK_TCPSocket::listen
  711. *
  712. * DESCRIPTION:
  713. *
  714. * Listen for a connection on this MacTCP socket.  When a connection is
  715. * requested, the TCPIOCompletionProc is called to handle establishing
  716. * the connection (which is done by creating a new socket for that connection
  717. * and then returning this socket to a listening state).
  718. *
  719. * PARAMETERS:
  720. *
  721. * int            -- unused
  722. *
  723. * RETURNS:
  724. *
  725. * int            -- Error value (0 = no error).  When error occurs, the global
  726. *                   errno contains a more detailed error value.
  727. *
  728. */
  729.  
  730. int CSK_TCPSocket::listen(int)
  731. {
  732.     OSErr            err;
  733.     TCPiopb *    pb;
  734.  
  735.     if (fSocketState != SKk_STATE_UNCONNECTED)
  736.         return SK_Error(EISCONN);
  737.  
  738.     fSocketState = SKk_STATE_LISTENING;
  739.     pb = GetPB();
  740.     pb->ioCRefNum = SKg_INETSockets.Driver();
  741.     pb->ioCompletion = TCPIOCompletionProc(tcp_listen_done);
  742.     pb->csCode = TCPPassiveOpen;
  743.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  744.     pb->csParam.open.ulpTimeoutValue = 255 /* seconds */;
  745.     pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
  746.     pb->csParam.open.commandTimeoutValue = 0 /* infinity */;
  747.     pb->csParam.open.remoteHost = 0;
  748.     pb->csParam.open.remotePort = 0;
  749.     pb->csParam.open.localHost = 0;
  750.     pb->csParam.open.localPort = fMySocketAddress.sin_port;
  751.     pb->csParam.open.dontFrag = 0;
  752.     pb->csParam.open.timeToLive = 0;
  753.     pb->csParam.open.security = 0;
  754.     pb->csParam.open.optionCnt = 0;
  755.  
  756.     err = PBControlAsync(ParmBlkPtr(pb));
  757.     if (err != 0) {
  758.         fSocketState = SKk_STATE_UNCONNECTED;
  759.         
  760.         return SK_TCPError(err);
  761.     }
  762.     
  763.     SAFESPIN(!pb->csParam.open.localPort, SKk_MISC, 0);
  764.         
  765.     if (errno) {
  766.         fSocketState = SKk_STATE_UNCONNECTED;
  767.         
  768.         return -1;
  769.     }
  770.  
  771.     fMySocketAddress.sin_addr.s_addr     = pb->csParam.open.localHost;
  772.     fMySocketAddress.sin_port             = pb->csParam.open.localPort;
  773.  
  774.     return 0;
  775. }
  776.  
  777.  
  778. /*************************************************************************** *
  779. * FUNCTION:
  780. *
  781. * CSK_TCPSocket::accept
  782. *
  783. * DESCRIPTION:
  784. *
  785. * Accept a connection request from a given host.
  786. *
  787. * PARAMETERS:
  788. *
  789. * void *            -- The internet number of the requesting host
  790. * int                -- The length of the above address structure
  791. *
  792. * RETURNS:
  793. *
  794. * CSK_Socket *        -- A newly created socket that will handle the newly
  795. *                       established connection (or nil if failed).
  796. *
  797. */
  798.  
  799. CSK_Socket * CSK_TCPSocket::accept(void *from, int *fromlen)
  800. {
  801.     CSK_TCPSocket *        sock;
  802.     TCPiopb *        pb;
  803.     int err;
  804.  
  805.     if (fSocketState == SKk_STATE_UNCONNECTED)
  806.         if (fLastAsyncErr) {
  807.             SK_TCPError(fLastAsyncErr);
  808.             fLastAsyncErr = 0;
  809.  
  810.             return nil;
  811.         } else
  812.             return (CSK_Socket *) SK_Error_nil(ENOTCONN);
  813.  
  814.     if (fSocketState != SKk_STATE_LISTENING && fSocketState != SKk_STATE_LIS_CON)
  815.         return (CSK_Socket *) SK_Error_nil(ENOTCONN);
  816.  
  817.     if (fSocketState == SKk_STATE_LISTENING) {
  818.  
  819.         if (fNonBlocking)
  820.             return (CSK_Socket *) SK_Error_nil(EWOULDBLOCK);
  821.  
  822.         /*    Spin till sock_tcp_listen_done runs. */
  823.         SPINP(fSocketState == SKk_STATE_LISTENING, SKk_MISC, 0);
  824.  
  825.         /* got notification - was it success? */
  826.         if (fSocketState != SKk_STATE_LIS_CON) {
  827.             (void) SK_TCPError(fLastAsyncErr);
  828.             fLastAsyncErr = 0;
  829.             return nil;
  830.         }
  831.     }
  832.  
  833.     /*
  834.      * Have connection.  Duplicate this socket.  The client gets the connection
  835.      * on the new socket and I create a new stream on the old socket and put it
  836.      * in listen state.
  837.      */
  838.     fSocketState     = SKk_STATE_CONNECTED;
  839.     sock        = new CSK_TCPSocket(this);
  840.  
  841.     if (!sock)
  842.     {
  843.         /*    Abort the incoming connection. */
  844.         pb                 = GetPB();
  845.         pb->csCode         = TCPAbort;
  846.  
  847.         PBControlSync(ParmBlkPtr(pb));
  848.  
  849.         fSocketState = SKk_STATE_UNCONNECTED;
  850.  
  851.         // Check for nasty error that once plagued us (will be removed eventually)
  852.         ASSERT(pb->ioResult != inProgress);
  853.  
  854.         /* try and put the socket back in listen mode */
  855.         if (listen(5) < 0)
  856.         {
  857.             fSocketState = SKk_STATE_UNCONNECTED;
  858.             return nil;        /* errno already set */
  859.         }
  860.         return (CSK_Socket *) SK_Error_nil(ENOMEM);
  861.     }
  862.  
  863.     /* Create a new MacTCP stream on the old socket and put it into */
  864.     /* listen state to accept more connections. */
  865.     fSocketState = SKk_STATE_UNCONNECTED;
  866.  
  867.     pb                                = GetPB();
  868.     pb->csCode                         = TCPCreate;
  869.     pb->csParam.create.rcvBuff         = (char *)NewPtr(SKk_StreamBufferSize);
  870.     pb->csParam.create.rcvBuffLen     = SKk_StreamBufferSize;
  871.     pb->csParam.create.notifyProc     = tcp_notify;
  872.     pb->csParam.create.userDataPtr    = Ptr(fSelf);
  873.  
  874.     err = PBControlSync(ParmBlkPtr(pb));
  875.     
  876.     // Check for nasty error that once plagued us (will be removed eventually)
  877.     ASSERT(pb->ioResult != inProgress);
  878.  
  879.     switch(err)
  880.     {
  881.         case noErr:                     break;
  882.         case invalidLength:             return (CSK_Socket *) SK_Error_nil(ENOBUFS);
  883.         case invalidBufPtr:             return (CSK_Socket *) SK_Error_nil(ENOBUFS);
  884.         case insufficientResources:     return (CSK_Socket *) SK_Error_nil(EMFILE);
  885.         default:                         return (CSK_Socket *) SK_Error_nil(ENETDOWN);
  886.     }
  887.  
  888.     fPeerSocketAddress.sin_family         = AF_INET;
  889.     fPeerSocketAddress.sin_addr.s_addr = 0;
  890.     fPeerSocketAddress.sin_port             = 0;
  891.  
  892.     bzero(&fPeerSocketAddress.sin_zero[0], 8);
  893.  
  894.     fLastAsyncErr                 = 0;
  895.     fStream                     = pb->tcpStream;
  896.  
  897.     if (listen(5) < 0) {
  898.         /* nothing to listen on */
  899.         fSocketState = SKk_STATE_UNCONNECTED;
  900.  
  901.         /* kill the incoming connection */
  902.         pb                    = sock->GetPB();
  903.         pb->csCode        = TCPRelease;
  904.  
  905.         if (!PBControlSync(ParmBlkPtr(pb)))
  906.             DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
  907.  
  908.         // Check for nasty error that once plagued us (will be removed eventually)
  909.         ASSERT(pb->ioResult != inProgress);
  910.         
  911.         return nil; /* errno set */
  912.     }
  913.  
  914.     /* return address of partner */
  915.     memcpy(from, &fPeerSocketAddress, *fromlen = MIN(*fromlen, sizeof(struct sockaddr_in)));
  916.  
  917.     return sock;
  918. }
  919.  
  920.  
  921. /*************************************************************************** *
  922. * FUNCTION:
  923. *
  924. * CSK_TCPSocket::recvfrom
  925. *
  926. * DESCRIPTION:
  927. *
  928. * recvfrom() attempts to receive a message (ie a datagram) on this socket
  929. *
  930. * PARAMETERS:
  931. *
  932. * void *        -- Pointer to buffer for returned bytes
  933. * int            -- Maximum number of bytes to read
  934. * int            -- unused
  935. * void *        -- Pointer to memory for return value (address of sender)
  936. * int *            -- Pointer to memory for length of return value
  937. *
  938. * RETURNS:
  939. *
  940. * int            -- Error return (0 = no error), -1 = error in which case
  941. *                   a more specific error code is stored in the global errno:
  942. *
  943. *    ESHUTDOWN    The socket has been shutdown for receive operations.
  944. *
  945. * The bytes received are read into the given buffer.
  946. *
  947. * The internet address of the caller and the length of that address
  948. * are placed into the last two parameters (void * and int).
  949. *
  950. * NOTES:
  951. *
  952. * Typically, read() is used with a TCP stream and recv() with
  953. * UDP where the idea of a message makes more sense. But in fact,
  954. * read() and recv() are equivalent.
  955. *
  956. * Regardless of non-blocking status, if less data is available
  957. * than has been requested, only that much data is returned.
  958. *
  959. * If the socket is marked for non-blocking I/O, and the socket
  960. * is empty, the operation will fail with the error EWOULDBLOCK.
  961. * Otherwise, the operation will block until data is available
  962. * or an error occurs.
  963. *
  964. * A return value of zero indicates that the stream has been
  965. * closed and all data has already been read. ie. end-of-file.
  966. *
  967. */
  968.  
  969. int CSK_TCPSocket::recvfrom(void * buffer, int buflen, int, void * from, int *fromlen)
  970. {
  971.     TCPiopb    *    pb;
  972.     u_long        dataavail;
  973.  
  974.     if (from)
  975.          getpeername(from, fromlen);
  976.     if (fStatus & SKk_STATUS_NOREAD)
  977.         return SK_Error(ESHUTDOWN);
  978.  
  979.     /* socket hasn't finished connecting yet */
  980.     if (fSocketState == SKk_STATE_CONNECTING)
  981.     {
  982.         if (fNonBlocking)
  983.             return SK_Error(EWOULDBLOCK);
  984.  
  985.         /* async connect and sync recv? */
  986.  
  987.         SPIN(fSocketState == SKk_STATE_CONNECTING,SKk_MISC,0);
  988.     }
  989.  
  990.     /* socket is not connected */
  991.     if (!(fSocketState == SKk_STATE_CONNECTED))
  992.     {
  993.         /* see if the connect died (pretty poor test) */
  994.         if (fSocketState == SKk_STATE_UNCONNECTED && fLastAsyncErr != 0 && fLastAsyncErr != 1)
  995.         {
  996.             (void) SK_TCPError(fLastAsyncErr);
  997.             fLastAsyncErr = 0;
  998.             return -1;
  999.         }
  1000.  
  1001.         /* I guess he just forgot */
  1002.         return SK_Error(ENOTCONN);
  1003.     }
  1004.  
  1005.     dataavail = Available();
  1006.  
  1007.     if (fNonBlocking && !dataavail) 
  1008.         return SK_Error(EWOULDBLOCK);
  1009.         
  1010.     fReceiveBuf    = (char *) buffer;
  1011.     fBytesReceived        = 0;
  1012.     fLastAsyncErr    = inProgress;
  1013.  
  1014.     pb = GetPB();
  1015.     pb->ioCompletion = TCPIOCompletionProc(tcp_recv_done);
  1016.     pb->csCode = TCPRcv;
  1017.     pb->csParam.receive.commandTimeoutValue = 0; /* seconds, 0 = blocking */
  1018.     pb->csParam.receive.rcvBuff = fReceiveBuf;
  1019.     pb->csParam.receive.rcvBuffLen = MIN(buflen,SKk_TCPMaxMessageSize);
  1020.  
  1021.     PBControlAsync(ParmBlkPtr(pb));
  1022.  
  1023.     /* This is potentially dangerous, as there doesn't seem to be a way to
  1024.         stop the receive call on an user abort.
  1025.     */
  1026.     SPIN(pb->ioResult==inProgress, SKk_STREAM_READ, buflen);
  1027.  
  1028.     if (pb->ioResult == commandTimeout)
  1029.         pb->ioResult = noErr;
  1030.  
  1031.     switch(pb->ioResult)
  1032.     {
  1033.         case noErr:
  1034.             fLastAsyncErr = noErr;
  1035.  
  1036.             return fBytesReceived;
  1037.  
  1038.         case connectionClosing:
  1039.         case connectionTerminated:
  1040.             return fBytesReceived;
  1041.  
  1042.         case commandTimeout: /* this one should be caught by sock_tcp_recv_done */
  1043.         case connectionDoesntExist:
  1044.         case invalidStreamPtr:
  1045.         case invalidLength:
  1046.         case invalidBufPtr:
  1047.         default:
  1048.             return SK_TCPError(pb->ioResult);
  1049.     }
  1050. }
  1051.  
  1052.  
  1053. /*************************************************************************** *
  1054. * FUNCTION:
  1055. *
  1056. * CSK_TCPSocket::sendto
  1057. *
  1058. * DESCRIPTION:
  1059. *
  1060. * sendto() is used to transmit a message from this socket to another socket.
  1061. *
  1062. * PARAMETERS:
  1063. *
  1064. * void *        -- Pointer to buffer containing bytes to send
  1065. * int            -- The number of bytes to send
  1066. * int            -- Flags (???)
  1067. * void *        -- Pointer to internet address to send to
  1068. * int             -- Length of above internet address structure
  1069. *
  1070. * RETURNS:
  1071. *
  1072. * This call returns the number of bytes sent, or -1 if an error occurred,
  1073. * in which case the global errno contains a more detailed error value:
  1074. *
  1075. *     EINVAL        The sum of the iov_len values in the iov array was
  1076. *                greater than 65535 (TCP) or 65507 (UDP) or there
  1077. *                were too many entries in the array (16 for TCP or
  1078. *                6 for UDP).
  1079. *
  1080. *     ESHUTDOWN    The socket has been shutdown for send operations.
  1081. *
  1082. *     EMSGSIZE    The message is too big to send in one datagram. (UDP)
  1083. *
  1084. *     ENOBUFS        The transmit queue is full. (UDP)
  1085. *
  1086. * The bytes received are read into the given buffer.
  1087. *
  1088. * NOTES:
  1089. *
  1090. * Typically, write() is used with a TCP stream and send() with
  1091. * UDP where the idea of a message makes more sense. But in fact,
  1092. * write() and send() are equivalent.
  1093. *
  1094. * Write() and send() operations are not considered complete
  1095. * until all data has been sent and acknowledged.
  1096. *
  1097. * If a socket is marked for non-blocking I/O, the operation
  1098. * will return an 'error' of EINPROGRESS.
  1099. *
  1100. * If the socket is not marked for non-blocking I/O, the write will
  1101. * block until space becomes available.
  1102. *
  1103. * write() and send() may be used only when the socket is in a connected
  1104. * state, sendto() may be used at any time.
  1105. *
  1106. */
  1107.  
  1108. int CSK_TCPSocket::sendto(void * buffer, int count, int flags, void * to, int)
  1109. {
  1110.     int            bytes,towrite;
  1111.     SKt_MiniWds *    thiswds;
  1112.     short            wdsnum;
  1113.     TCPiopb *    pb;
  1114.     SKt_MiniWds        wdsarray[SKk_TCPMaxWds];
  1115.  
  1116.     if (fStatus & SKk_STATUS_NOWRITE)
  1117.         return SK_Error(ESHUTDOWN);
  1118.  
  1119.     if (to != NULL) /* sendto */
  1120.         return SK_Error(EOPNOTSUPP);
  1121.     if (fSocketState != SKk_STATE_CONNECTED && fSocketState != SKk_STATE_CONNECTING)
  1122.         return SK_Error(ENOTCONN);
  1123.  
  1124.     /* socket hasn't finished connecting yet */
  1125.     if (fSocketState == SKk_STATE_CONNECTING) {
  1126.         if (fNonBlocking) 
  1127.             return SK_Error(EALREADY);
  1128.  
  1129.         /* async connect and sync send? */
  1130.         SPIN(fSocketState == SKk_STATE_CONNECTING, SKk_MISC, 0);
  1131.     }
  1132.  
  1133.     /* socket is not connected */
  1134.     if (!(fSocketState == SKk_STATE_CONNECTED)) {
  1135.         /* see if a previous operation failed */
  1136.         if (fSocketState == SKk_STATE_UNCONNECTED && fLastAsyncErr != 0) {
  1137.             (void) SK_TCPError(fLastAsyncErr);
  1138.             fLastAsyncErr = 0;
  1139.             return -1;
  1140.         }
  1141.  
  1142.         /* I guess he just forgot */
  1143.         return SK_Error(ENOTCONN);
  1144.     }
  1145.  
  1146.     pb                = GetPB();
  1147.     pb->csCode         = TCPStatus;
  1148.  
  1149.     if (PBControlSync(ParmBlkPtr(pb)))
  1150.         bytes = 0;
  1151.     else {
  1152.         bytes = pb->csParam.status.sendWindow - pb->csParam.status.amtUnackedData;
  1153.  
  1154.         if (bytes < 0)
  1155.             bytes = 0;
  1156.     }
  1157.  
  1158.     // Check for nasty error that once plagued us (will be removed eventually)
  1159.     ASSERT(pb->ioResult != inProgress);
  1160.  
  1161.     if (fNonBlocking)
  1162.         if (!bytes) 
  1163.             return SK_Error(EWOULDBLOCK);
  1164.         else if (bytes < count)
  1165.             count = bytes;
  1166.  
  1167.     bytes    =    count;                                        /* save count before we nuke it */
  1168.     memset(wdsarray, 0, SKk_TCPMaxWds*sizeof(SKt_MiniWds));    /* clear up terminus and mark empty */
  1169.     thiswds = wdsarray;
  1170.     wdsnum = 0;
  1171.  
  1172.     while (count > 0) {
  1173.         /* make sure the thing that just finished worked ok */
  1174.         if (fLastAsyncErr) {
  1175.             (void) SK_Error(fLastAsyncErr);
  1176.             fLastAsyncErr = 0;
  1177.             return -1;
  1178.         }
  1179.  
  1180.         towrite=MIN(count,SKk_TCPMaxMessageSize);
  1181.  
  1182.         /* find a clean wds */
  1183.  
  1184.         while (thiswds->length != 0) {
  1185.             wdsnum = (short)((wdsnum+1)%SKk_TCPMaxWds); /* generates compiler warning w/o short - why? */
  1186.             if (wdsnum)
  1187.                 thiswds++;
  1188.             else
  1189.                 thiswds = wdsarray;
  1190.             SPIN(false, SKk_STREAM_WRITE, count);    /* spin once */
  1191.         }
  1192.  
  1193.         /* find a clean pb */
  1194.  
  1195.         thiswds->length    = (short)towrite;
  1196.         thiswds->ptr = (char *) buffer;
  1197.         pb = GetPB();
  1198.         pb->ioCompletion = TCPIOCompletionProc(tcp_send_done);
  1199.         pb->csCode = TCPSend;
  1200.         pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
  1201.         pb->csParam.send.ulpTimeoutValue = 60 /* seconds */;
  1202.         pb->csParam.send.ulpTimeoutAction = 1 /* 0:abort 1:report */;
  1203.         pb->csParam.send.pushFlag = count <= SKk_TCPMaxMessageSize;
  1204.         pb->csParam.send.urgentFlag = flags & MSG_OOB;
  1205.         pb->csParam.send.wdsPtr = (Ptr)thiswds;
  1206.         pb->csParam.send.sendFree = 0;
  1207.         pb->csParam.send.sendLength = 0;
  1208.  
  1209.         PBControlAsync(ParmBlkPtr(pb));
  1210.  
  1211.         SPIN(false, SKk_STREAM_WRITE, count);
  1212.         count     -= towrite;
  1213.         buffer    = (char *) buffer + towrite;
  1214.     }
  1215.  
  1216.     SPIN(pb->ioResult == inProgress, SKk_STREAM_WRITE, 0);
  1217.  
  1218.     if (!pb->ioResult)
  1219.         return(bytes);
  1220.     else
  1221.         return SK_TCPError(pb->ioResult);
  1222. }
  1223.  
  1224.  
  1225. /*************************************************************************** *
  1226. * FUNCTION:
  1227. *
  1228. * CSK_TCPSocket::select
  1229. *
  1230. * DESCRIPTION:
  1231. *
  1232. * Check this socket for readiness to read or write, or for whether
  1233. * it has an exceptional condition pending.  Each of the three
  1234. * flags passed as parameters are set accordingly; only those which
  1235. * were initially set to TRUE are checked.
  1236. *
  1237. * PARAMETERS:
  1238. *
  1239. * Boolean *        -- Can read (???)
  1240. * Boolean *     -- Can write (???)
  1241. * Boolean *        -- Exception (???)
  1242. *
  1243. * RETURNS:
  1244. *
  1245. * int            -- The total number of return flags set to TRUE.
  1246. *
  1247. */
  1248.  
  1249. int CSK_TCPSocket::select(Boolean * canRead, Boolean * canWrite, Boolean * )
  1250. {
  1251.     int        goodies     =     0;
  1252.  
  1253.     if (canRead)
  1254.         switch (fSocketState) {
  1255.             case SKk_STATE_LIS_CON:
  1256.                 *canRead    = true;
  1257.                  ++goodies;
  1258.                 break;
  1259.  
  1260.             case SKk_STATE_CONNECTED:
  1261.                 if (Available()) {
  1262.                     *canRead    = true;
  1263.                     ++goodies;
  1264.                 }
  1265.                 break;
  1266.  
  1267.             case SKk_STATE_UNCONNECTED:
  1268.             case SKk_STATE_CLOSING:
  1269.                 *canRead    = true;        /* CAN THIS REALLY BE CORRECT ??!?!?  S.D. 9/1/93 */
  1270.                 ++goodies;                /* Should either be Available() or FALSE ?? */
  1271.                 break;
  1272.         }
  1273.  
  1274.     if (canWrite) 
  1275.         switch (fSocketState) {
  1276.             case SKk_STATE_CONNECTING:
  1277.                 break;
  1278.             default:
  1279.                 *canWrite = true;
  1280.                 ++goodies;
  1281.         }
  1282.  
  1283.     return goodies;
  1284. }
  1285.  
  1286.  
  1287.  
  1288. /* end of SK_TCP.cc */
  1289.  
  1290.  
  1291.